package com.example.permissionservice.controller;

import com.example.permissionservice.pojo.Role;
import com.example.permissionservice.pojo.UserWithRole;
import com.example.permissionservice.pojo.UserWithRoleExample;
import com.example.permissionservice.service.RoleService;
import com.example.permissionservice.service.UserRoleRelationService;
import com.example.permissionservice.service.UserWithRoleService;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.myprojects.common.dto.Msg;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;
import java.util.Map;

@CrossOrigin
@Controller
@RequestMapping(value = "/user-with-role-curd")
public class UserWithRoleController {

    @Autowired
    UserWithRoleService userWithRoleService;

    @Autowired
    UserRoleRelationService userRoleRelationService;

    @Autowired
    RoleService roleService;

    /**
     * 该方法用于获取全部的角色
     */
    @RequestMapping(value = "/roles", method = RequestMethod.GET)
    @ResponseBody
    public Msg getAllRoles() {//普通
        Msg result;//要返回的结果
        try {
            List<Role> roleList = roleService.selectAllRole();
            result = Msg.succeed();
            result.addData("roleList", roleList);
        } catch (Exception e) {
            e.printStackTrace();
            result = Msg.failed();
            result.setMsg("服务端处理异常!");
        }

        return result;
    }

    /**
     * 该方法用于分页查询所有的用户信息(非员工)
     */
    @RequestMapping(value = "/users", method = RequestMethod.GET)
    @ResponseBody
    public Msg selectUsersByPageNum(
            @RequestParam(value = "pn", defaultValue = "1") Integer pageNum,
            @RequestParam(value = "size", defaultValue = "10") Integer pageSize,
            @RequestParam(value = "search", defaultValue = "") String searchStr
    ) {//普通
        Msg result;//要返回的结果
        try {
            //在查询之前调用，要设置查询的页数和每页的大小
            PageHelper.startPage(pageNum, pageSize);
            UserWithRoleExample example;
            //如果搜索条件为空
            if ("".equals(searchStr.trim())) {
                example = null;//则搜索条件为空，这样就能直接查询全部
            } else {//否则就装配搜索条件
                example = new UserWithRoleExample();
                try {//尝试转换，不行就算
                    Integer id = Integer.parseInt(searchStr);
                    example.or().andIdEqualTo(id);
                } catch (Exception e) {}
                example.or().andUsernameLike("%" + searchStr + "%");
                example.or().andNicknameLike("%" + searchStr + "%");
                example.or().andEmailLike("%" + searchStr + "%");
            }
            //startPage后紧跟的查询就是一个分页查询
            List<UserWithRole> userList = userWithRoleService.selectByExample(example);
            //使用PageInfo包装查询后的结果，需要将pageInfo交给页面
            //将查询出来用户信息加入pageInfo，并连续显示5页
            PageInfo pageInfo = new PageInfo(userList, 5);
            //生成返回成功的结果
            result = Msg.succeed();
            //将pageInfo加入返回的结果中
            result.addData("pageInfo", pageInfo);
            System.out.println(result.getDataMap());
        } catch (Exception e) {
            e.printStackTrace();
            result = Msg.failed();
            result.setMsg("服务端处理异常!");
        }

        return result;
    }

    /**
     * 该方法用于检查新增用户的信息
     */
    @RequestMapping(value = "/checkUser", method = RequestMethod.POST)
    @ResponseBody
    public Msg checkNewUser(@Valid @RequestBody UserWithRole user, BindingResult result) {
        Msg msg = null;
        //先检查用户信息有没有错误
        Map<String, Object> errorMap = userWithRoleService.checkNewUser(user, result);

        //如果都无误，则提示可以保存
        if (errorMap.size() < 1) {
            msg = Msg.succeed();
            msg.setMsg("用户信息验证无误，允许新增。");
        } else {
            msg = Msg.failed();
            msg.setMsg("用户信息验证有误，禁止新增！");
            //将详细错误信息添加进msg
            msg.addData("fieldErrors", errorMap);
        }
        return msg;
    }

    /**
     * 该方法用于检查更新用户的信息
     */
    @RequestMapping(value = "/checkUser", method = RequestMethod.PUT)
    @ResponseBody
    public Msg checkUpdateUser(@Valid @RequestBody UserWithRole user, BindingResult result) {
        Msg msg = null;
        //先检查用户信息有没有错误
        Map<String, Object> errorMap = userWithRoleService.checkUpdateUser(user, result);

        //如果都无误，则提示可以保存
        if (errorMap.size() < 1) {
            msg = Msg.succeed();
            msg.setMsg("用户信息验证无误，允许更新。");
        } else {
            msg = Msg.failed();
            msg.setMsg("用户信息验证有误，禁止更新！");
            //将详细错误信息添加进msg
            msg.addData("fieldErrors", errorMap);
        }
        return msg;
    }

    /**
     * 该方法用于保存用户
     */
    @RequestMapping(value = "/users", method = RequestMethod.POST)
    @ResponseBody
    public Msg saveUser(@Valid @RequestBody UserWithRole user, BindingResult result) {
        Msg msg = null;

        //先检查用户信息有没有错误
        Map<String, Object> errorMap = userWithRoleService.checkUpdateUser(user, result);

        //如果都无误，则尝试保存
        if (errorMap.size() < 1) {
            //新建该角色，并注入新建后的id
            int iSaveResult = userWithRoleService.insertSelective(user);
            //新建该角色拥有的资源关系
            userRoleRelationService.updateRelationByUser(user);
            if (iSaveResult > 0) {
                msg = Msg.succeed();
                msg.setMsg("保存用户成功！");
            } else {
                msg = Msg.failed();
                msg.setMsg("保存用户失败！");
            }
        } else {
            msg = Msg.failed();
            msg.setMsg("保存用户失败！");
            //将详细错误信息添加进msg
            msg.addData("fieldErrors", errorMap);
        }

        return msg;
    }

    /**
     * 该方法用于更新用户(该方法会更新用户所拥有的角色)
     */
    @RequestMapping(value = "/users", method = RequestMethod.PUT)
    @ResponseBody
    public Msg updateUser(@Valid @RequestBody UserWithRole user, BindingResult result) {
        Msg msg = null;
        System.out.println("接收到的需更新的用户信息为：" + user);

        //先检查用户信息有没有错误
        Map<String, Object> errorMap = userWithRoleService.checkUpdateUser(user, result);
        System.out.println("错误信息为：" + errorMap);

        //如果都无误，则尝试保存
        if (errorMap.size() < 1) {
//        if (true) {
            int iResult = userWithRoleService.updateByPrimaryKeySelective(user);
            //修改该角色拥有的资源关系
            userRoleRelationService.updateRelationByUser(user);
            if (iResult > 0) {
                msg = Msg.succeed();
                msg.setMsg("更新成功，共更新" + iResult + "个用户");
            } else {
                msg = Msg.failed();
                msg.setMsg("更新失败!");
            }
        } else {
            msg = Msg.failed();
            msg.setMsg("更新失败！");
            //将详细错误信息添加进msg
            msg.addData("fieldErrors", errorMap);
        }

        return msg;
    }


//    /**
//     * 该方法用于更新用户(该方法不会更新用户所拥有的角色)
//     */
//    @RequestMapping(value = "/users_without_role", method = RequestMethod.PUT)
//    @ResponseBody
//    public Msg updateUserWithoutRole(@Valid @RequestBody UserWithRole user, BindingResult result) {
//        Msg msg = null;
//        System.out.println("接收到的需更新的用户信息为：" + user);
//
//        //先检查用户信息有没有错误
//        Map<String, Object> errorMap = userWithRoleService.checkUpdateUser(user, result);
//        System.out.println("错误信息为：" + errorMap);
//
//        //如果都无误，则尝试保存
//        if (errorMap.size() < 1) {
//            int iResult = userWithRoleService.updateByPrimaryKeySelective(user);
//            if (iResult > 0) {
//                msg = Msg.succeed();
//                msg.setMsg("更新成功，共更新" + iResult + "个用户");
//            } else {
//                msg = Msg.failed();
//                msg.setMsg("更新失败!");
//            }
//        } else {
//            msg = Msg.failed();
//            msg.setMsg("更新失败！");
//            //将详细错误信息添加进msg
//            msg.addData("fieldErrors", errorMap);
//        }
//
//        return msg;
//    }

    /**
     * 该方法用于一次删除多个用户
     */
    @RequestMapping(value = "/users", method = RequestMethod.DELETE)
    @ResponseBody
    public Msg deleteLotsUser(@RequestParam List<Integer> idList) {
        Msg msg = null;

        int iResult = userWithRoleService.deleteLotsByPrimaryKey(idList);
        int iDeleteRelation = userRoleRelationService.deleteRelationByUserIdList(idList);
        if (iResult > 0) {
            msg = Msg.succeed();
            msg.setMsg("删除成功，共删除" + iResult + "个用户");
        } else {
            msg = Msg.failed();
            msg.setMsg("删除失败!");
        }
        return msg;
    }


}
